home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 1999 January / PC Plus Super CD No55a (PCP-147A-1-99) (Disc 1) (1998).iso / linux / developers / visualtcl / windows / vtcl / lib / widget.tcl < prev   
Encoding:
Text File  |  1998-02-01  |  18.1 KB  |  630 lines
  1. ##############################################################################
  2. # $Id: widget.tcl,v 1.14 1998/02/02 05:11:33 stewart Exp $
  3. #
  4. # widget.tcl - procedures for manipulating widget information
  5. #
  6. # Copyright (C) 1996-1997 Stewart Allen
  7. #
  8. # This program is free software; you can redistribute it and/or
  9. # modify it under the terms of the GNU General Public License
  10. # as published by the Free Software Foundation; either version 2
  11. # of the License, or (at your option) any later version.
  12. #
  13. # This program is distributed in the hope that it will be useful,
  14. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. # GNU General Public License for more details.
  17. #
  18. # You should have received a copy of the GNU General Public License
  19. # along with this program; if not, write to the Free Software
  20. # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. ##############################################################################
  23. #
  24.  
  25. #
  26. # Given a full widget path, returns a name with "$base" replacing
  27. # the first widget element.
  28. #
  29. proc vTcl:base_name {target} {
  30.     set l [split $target .]
  31.     set name "\$base"
  32.     foreach i [lrange $l 2 end] {
  33.         append name ".$i"
  34.     }
  35.     return $name
  36. }
  37.  
  38. proc vTcl:properties {target} {
  39.     vTcl:status "Properties not implemented"
  40. }
  41.  
  42. #
  43. # Given two compatible widgets, sets up a scrollbar
  44. # link (i.e. textfield and scrollbar)
  45. #
  46. proc vTcl:bind_scrollbar {t1 t2} {
  47.     global vTcl
  48.     set c1 [winfo class $t1]
  49.     set c2 [winfo class $t2]
  50.     if { $c1 == "Scrollbar" } {
  51.         set t3 $t1; set t1 $t2; set t2 $t3
  52.         set c3 $c1; set c1 $c2; set c2 $c3
  53.     } elseif { $c2 == "Scrollbar" } {
  54.     } else {
  55.         return
  56.     }
  57.     switch [lindex [$t2 conf -orient] 4] {
  58.         vert -
  59.         vertical { set scr_cmd -yscrollcommand; set v_cmd yview }
  60.         default  { set scr_cmd -xscrollcommand; set v_cmd xview }
  61.     }
  62.     switch $c1 {
  63.         Listbox -
  64.         Canvas -
  65.         Text {
  66.             $t1 conf $scr_cmd "$t2 set"
  67.             $t2 conf -command "$t1 $v_cmd"
  68.         }
  69.         Entry {
  70.             if {$v_cmd == "xview"} {
  71.                 $t1 conf $scr_cmd "$t2 set"
  72.                 $t2 conf -command "$t1 $v_cmd"
  73.             }
  74.         }
  75.     }
  76. }
  77.  
  78. #
  79. # Shows a "hidden" object from information stored
  80. # during the hide. Hidden object attributes are
  81. # not currently saved in the project. FIX.
  82. #
  83. proc vTcl:show {target} {
  84.     global vTcl
  85.     if {![winfo viewable $target]} {
  86.         if {[catch {eval $vTcl(hide,$target,m) $target $vTcl(hide,$target,i)}] == 1} {
  87.             catch {$vTcl(w,def_mgr) $target $vTcl($vTcl(w,def_mgr),insert)}
  88.         }
  89.     }
  90. }
  91.  
  92. #
  93. # Withdraws a widget from display.
  94. #
  95. proc vTcl:hide {} {
  96.     global vTcl
  97.     if {$vTcl(w,manager) != "wm" && $vTcl(w,widget) != ""} {
  98.         lappend vTcl(hide) $vTcl(w,widget)
  99.         set vTcl(hide,$vTcl(w,widget),m) $vTcl(w,manager)
  100.         set vTcl(hide,$vTcl(w,widget),i) [$vTcl(w,manager) info $vTcl(w,widget)]
  101.         $vTcl(w,manager) forget $vTcl(w,widget)
  102.         vTcl:destroy_handles
  103.     }
  104. }
  105.  
  106. #
  107. # Sets the current widget as the insertion point
  108. # for new widgets.
  109. #
  110. proc vTcl:set_insert {} {
  111.     global vTcl
  112.     set vTcl(w,insert) $vTcl(w,widget)
  113. }
  114.  
  115. proc vTcl:select_parent {} {
  116.     global vTcl
  117.     vTcl:active_widget [winfo parent $vTcl(w,widget)]
  118.     vTcl:set_insert
  119. }
  120.  
  121. proc vTcl:select_toplevel {} {
  122.     global vTcl
  123.     vTcl:active_widget [winfo toplevel $vTcl(w,widget)]
  124.     vTcl:set_insert
  125. }
  126.  
  127. proc vTcl:active_widget {target} {
  128.     global vTcl
  129.     if {$target == ""} {return}
  130.     if {$vTcl(w,widget) != "$target"} {
  131.         vTcl:select_widget $target
  132.         vTcl:attrbar_color $target
  133.         set vTcl(redo) [vTcl:dump_widget_quick $target]
  134.         if {$vTcl(w,class) == "Toplevel"} {
  135.             vTcl:destroy_handles
  136.             set vTcl(w,insert) $target
  137.         } else {
  138.             vTcl:create_handles $target
  139.             vTcl:place_handles $target
  140.             if {$vTcl(w,class) == "Frame" || $vTcl(w,class) == "Canvas"} {
  141.                 set vTcl(w,insert) $target
  142.             } else {
  143.                 set vTcl(w,insert) [winfo parent $target]
  144.             }
  145.         }
  146.     } elseif {$vTcl(w,class) == "Toplevel"} {
  147.         set vTcl(w,insert) $target
  148.     }
  149. }
  150.  
  151. proc vTcl:select_widget {target} {
  152.     global vTcl
  153.     if {$target == $vTcl(w,widget)} {return}
  154.     set vTcl(w,last_class) $vTcl(w,class)
  155.     set vTcl(w,last_widget) $vTcl(w,widget)
  156.     set vTcl(w,last_manager) $vTcl(w,manager)
  157.     vTcl:update_widget_info $target
  158.     vTcl:prop:update_attr
  159.     vTcl:get_bind $target
  160. }
  161.  
  162. #
  163. # Recurses a widget tree ignoring toplevels
  164. #
  165. proc vTcl:widget_tree {target} {
  166.     global vTcl
  167.     if {$target == ".vTcl" || [string range $target 0 4] == ".__tk"} {
  168.         return
  169.     }
  170.     set output "$target "
  171.     if {$vTcl([vTcl:get_class $target],dump_children) == "0"} {
  172.         return $output
  173.     }
  174.     set c [vTcl:get_children $target]
  175.     foreach i $c {
  176.         set mgr [winfo manager $i]
  177.         set class [vTcl:get_class $i]
  178.         if {$class != "Toplevel"} {
  179.             append output [vTcl:widget_tree $i]
  180.         }
  181.     }
  182.     return $output
  183. }
  184.  
  185. #
  186. # Recurses a widget tree with the option of not ignoring built-ins
  187. #
  188. proc vTcl:list_widget_tree {target {which ""}} {
  189.     if {$which == ""} {
  190.         if {$target == ".vTcl" || [string range $target 0 4] == ".__tk"} {
  191.             return
  192.         }
  193.     }
  194.     set w_tree "$target "
  195.     set children [vTcl:get_children $target]
  196.     foreach i $children {
  197.         append w_tree "[vTcl:list_widget_tree $i $which] "
  198.     }
  199.     return $w_tree
  200. }
  201.  
  202. ##############################################################################
  203. # WIDGET INFO ROUTINES
  204. ##############################################################################
  205. proc vTcl:split_info {target} {
  206.     global vTcl
  207.     set index 0
  208.     set mgr $vTcl(w,manager)
  209.     set mgr_info [$mgr info $target]
  210.     set vTcl(w,info) $mgr_info
  211.     if { $vTcl(var_update) == "yes" } {
  212.         set index a
  213.         foreach i $mgr_info {
  214.             if { $index == "a" } {
  215.                 set var vTcl(w,$mgr,$i)
  216.                 set last $i
  217.                 set index b
  218.             } else {
  219.                 set $var $i
  220.                 set index a
  221.             }
  222.         }
  223.     }
  224.     if {$mgr == "grid"} {
  225.         set p [winfo parent $target]
  226.         set pre g
  227.         set gcolumn $vTcl(w,grid,-column)
  228.         set grow $vTcl(w,grid,-row)
  229.         foreach a {column row} {
  230.             foreach b {weight minsize} {
  231.                 set num [subst $$pre$a]
  232.                 if [catch {
  233.                     set x [expr round([grid ${a}conf $p $num -$b])]
  234.                 }] {set x 0}
  235.                 set vTcl(w,grid,$a,$b) $x
  236.             }
  237.         }
  238.     }
  239. }
  240.  
  241. proc vTcl:split_wm_info {target} {
  242.     global vTcl
  243.     set vTcl(w,info) ""
  244.     foreach i $vTcl(attr,tops) {
  245.         if {$i == "geometry"} {
  246.             #
  247.             # because window managers behave unpredictably with wm and
  248.             # winfo, one is used for editing and the other for saving
  249.             #
  250.             if {$vTcl(mode) == "EDIT"} {
  251.                 set vTcl(w,wm,$i) [winfo $i $target]
  252.             } else {
  253.                 set vTcl(w,wm,$i) [wm $i $target]
  254.             }
  255.         } else {
  256.             set vTcl(w,wm,$i) [wm $i $target]
  257.         }
  258.     }
  259.     set vTcl(w,wm,class) [winfo class $target]
  260.     if { $vTcl(var_update) == "yes" } {
  261.         set geo [split $vTcl(w,wm,geometry) "+"]
  262.         set geo_hw [split [lindex $geo 0] x]
  263.         set vTcl(w,wm,geometry,w)    [lindex $geo_hw 0]
  264.         set vTcl(w,wm,geometry,h)    [lindex $geo_hw 1]
  265.         set vTcl(w,wm,geometry,x)    [lindex $geo 1]
  266.         set vTcl(w,wm,geometry,y)    [lindex $geo 2]
  267.         set vTcl(w,wm,minsize,x)     [lindex $vTcl(w,wm,minsize) 0]
  268.         set vTcl(w,wm,minsize,y)     [lindex $vTcl(w,wm,minsize) 1]
  269.         set vTcl(w,wm,maxsize,x)     [lindex $vTcl(w,wm,maxsize) 0]
  270.         set vTcl(w,wm,maxsize,y)     [lindex $vTcl(w,wm,maxsize) 1]
  271.         set vTcl(w,wm,aspect,minnum) [lindex $vTcl(w,wm,aspect) 0]
  272.         set vTcl(w,wm,aspect,minden) [lindex $vTcl(w,wm,aspect) 1]
  273.         set vTcl(w,wm,aspect,maxnum) [lindex $vTcl(w,wm,aspect) 2]
  274.         set vTcl(w,wm,aspect,maxden) [lindex $vTcl(w,wm,aspect) 3]
  275.         set vTcl(w,wm,resizable,w)   [lindex $vTcl(w,wm,resizable) 0]
  276.         set vTcl(w,wm,resizable,h)   [lindex $vTcl(w,wm,resizable) 1]
  277.     }
  278. }
  279.  
  280. proc vTcl:get_grid_stickies {sticky} {
  281.     global vTcl
  282.     set len [string length $sticky]
  283.     foreach i {n s e w} {
  284.         set vTcl(grid,sticky,$i) ""
  285.     }
  286.     for {set i 0} {$i < $len} {incr i} {
  287.         set val [string index $sticky $i]
  288.         set vTcl(grid,sticky,$val) $val
  289.     }
  290. }
  291.  
  292. proc vTcl:update_widget_info {target} {
  293.     global vTcl widget
  294.     update idletasks
  295.     set vTcl(w,widget) $target
  296.     set vTcl(w,didmove) 0
  297.     set vTcl(w,options) ""
  298.     set vTcl(w,optlist) ""
  299.     if {![winfo exists $target]} {return}
  300.     foreach i $vTcl(attr,winfo) {
  301.         set vTcl(w,$i) [winfo $i $target]
  302.     }
  303.     set vTcl(w,class) [vTcl:get_class $target]
  304.     set vTcl(w,r_class) [winfo class $target]
  305.     set vTcl(w,conf) [$target configure]
  306.     switch $vTcl(w,class) {
  307.         Toplevel {
  308.             set vTcl(w,opt,-text) [wm title $target]
  309.         }
  310.         default {
  311.             set vTcl(w,opt,-text) ""
  312.         }
  313.     }
  314.     switch $vTcl(w,manager) {
  315.         {} {}
  316.         grid -
  317.         pack -
  318.         place {
  319.             vTcl:split_info $target
  320.         }
  321.         wm {
  322.             if { $vTcl(w,class) != "Menu" } {
  323.                 vTcl:split_wm_info $target
  324.             }
  325.         }
  326.     }
  327.     set vTcl(w,options) [vTcl:conf_to_pairs $vTcl(w,conf) set]
  328.     if {[catch {set vTcl(w,alias) $widget(rev,$target)}]} {
  329.         set vTcl(w,alias) ""
  330.     }
  331. }
  332.  
  333. proc vTcl:conf_to_pairs {conf opt} {
  334.     global vTcl
  335.     set pairs ""
  336.     foreach i $conf {
  337.         set option [lindex $i 0]
  338.         set def [lindex $i 3]
  339.         set value [lindex $i 4]
  340.         if {$value != $def && $option != "-class"} {
  341.             lappend pairs $option $value
  342.         }
  343.         if {$opt == "set"} {
  344.             lappend vTcl(w,optlist) $option
  345.             set vTcl(w,opt,$option) $value
  346.         }
  347.     }
  348.     return $pairs
  349. }
  350.  
  351. proc vTcl:new_widget_name {type base} {
  352.     global vTcl
  353.     while { 1 } {
  354.         if $vTcl(pr,shortname) {
  355.             set num "[string range $type 0 2]$vTcl(item_num)"
  356.         } else {
  357.             set num "$type$vTcl(item_num)"
  358.         }
  359.         incr vTcl(item_num)
  360.         if {$base != "." && $type != "toplevel"} {
  361.             set new_widg $base.$num
  362.         } else {
  363.             set new_widg .$num
  364.         }
  365.         if { ![winfo exists $new_widg] } { break }
  366.     }
  367.     return $new_widg
  368. }
  369.  
  370. proc vTcl:setup_vTcl:bind {target} {
  371.     global vTcl
  372.     set bindlist [vTcl:list_widget_tree $target all]
  373.     update idletasks
  374.     foreach i $bindlist {
  375.         if { [lsearch [bindtags $target] vTcl(a)] < 0 } {
  376.             set tmp [bindtags $target]
  377.             bindtags $target "vTcl(a) $tmp"
  378.         }
  379.     }
  380. }
  381.  
  382. proc vTcl:setup_bind {target} {
  383.     global vTcl
  384.     if {[lsearch [bindtags $target] vTcl(b)] < 0} {
  385.         set vTcl(bindtags,$target) [bindtags $target]
  386.         if {[vTcl:get_class $target] == "Toplevel"} {
  387.             wm protocol $target WM_DELETE_WINDOW "vTcl:hide_top $target"
  388.             if {$vTcl(pr,winfocus) == 1} {
  389.                 wm protocol $target WM_TAKE_FOCUS "vTcl:wm_take_focus $target"
  390.             }
  391.             bindtags $target "vTcl(bindtags,$target) vTcl(b) vTcl(c)"
  392.         } else {
  393.             bindtags $target vTcl(b)
  394.         }
  395.     }
  396. }
  397.  
  398. proc vTcl:switch_mode {} {
  399.     global vTcl
  400.     if {$vTcl(mode) == "EDIT"} {
  401.         vTcl:setup_unbind_tree .
  402.     } else {
  403.         vTcl:setup_bind_tree .
  404.     }
  405. }
  406.  
  407. proc vTcl:setup_bind_tree {target} {
  408.     global vTcl
  409.     set bindlist [vTcl:list_widget_tree $target]
  410.     update idletasks
  411.     foreach i $bindlist {
  412.         vTcl:setup_bind $i
  413.     }
  414.     set vTcl(mode) "EDIT"
  415. }
  416.  
  417. proc vTcl:setup_unbind {target} {
  418.     global vTcl
  419.     if { [lsearch [bindtags $target] vTcl(b)] >= 0 } {
  420.         bindtags $target $vTcl(bindtags,$target)
  421.     }
  422. }
  423.  
  424. proc vTcl:setup_unbind_tree {target} {
  425.     global vTcl
  426.     vTcl:select_widget .
  427.     vTcl:destroy_handles
  428.     set bindlist [vTcl:list_widget_tree $target]
  429.     update idletasks
  430.     foreach i $bindlist {
  431.         vTcl:setup_unbind $i
  432.     }
  433.     set vTcl(mode) "TEST"
  434. }
  435.  
  436. ##############################################################################
  437. # INSERT NEW WIDGET ROUTINE
  438. ##############################################################################
  439. proc vTcl:new_widget {type {options ""}} {
  440.     global vTcl
  441.     if {$vTcl(mode) == "TEST"} {
  442.         vTcl:error "Inserting widgets is not\nallowed in Test mode."
  443.         return
  444.     }
  445.     global vTcl
  446.     if { ($vTcl(w,insert) == "." && $type != "toplevel") ||
  447.          ([winfo exists $vTcl(w,insert)] == 0 && $type != "toplevel")} {
  448.         vTcl:dialog "No insertion point set!"
  449.         return
  450.     }
  451.     set vTcl(mgrs,update) no
  452.     if $vTcl(pr,getname) {
  453.         set new_widg [vTcl:get_name $type]
  454.     } else {
  455.         set new_widg [vTcl:new_widget_name $type $vTcl(w,insert)]
  456.     }
  457.     if {$new_widg != ""} {
  458.         vTcl:create_widget $type $options $new_widg
  459.     }
  460. }
  461.  
  462. proc vTcl:create_widget {type options new_widg} {
  463.     global vTcl
  464.     set do ""
  465.     set undo ""
  466.     if {$vTcl(pr,getname) == 1} {
  467.         if { $vTcl(w,insert) == "." } {
  468.             set new_widg ".$new_widg"
  469.         } else {
  470.             set new_widg "$vTcl(w,insert).$new_widg"
  471.         }
  472.     }
  473.     append do "$type $new_widg $vTcl($type,insert) $options;"
  474.     if {[info procs vTcl:widget:$type:inscmd] != ""} {
  475.         append do "[vTcl:widget:$type:inscmd $new_widg];"
  476.     }
  477.     if {$type != "toplevel"} {
  478.         append do "$vTcl(w,def_mgr) $new_widg $vTcl($vTcl(w,def_mgr),insert);"
  479.     }
  480.     append do "vTcl:setup_bind_tree $new_widg; "
  481.     append do "vTcl:active_widget $new_widg; "
  482.     if {$undo == ""} {
  483.         set undo "destroy $new_widg; vTcl:active_widget [list $vTcl(w,widget)];"
  484.     }
  485.     vTcl:push_action $do $undo
  486.     update idletasks
  487.     set vTcl(mgrs,update) yes
  488.     return $new_widg
  489. }
  490.  
  491. proc vTcl:set_alias {target} {
  492.     global vTcl widget
  493.     if {$target == ""} {return}
  494.     set was ""
  495.     if {![llength [array get widget "rev,$target"]]} {
  496.         set alias [vTcl:get_string "Widget alias for $vTcl(w,class)" $target]
  497.     } else {
  498.         set was $widget(rev,$target)
  499.         set alias \
  500.             [vTcl:get_string "Widget alias for $vTcl(w,class)" $target $was]
  501.     }
  502.     catch {
  503.         unset widget($was)
  504.         unset widget(rev,$target)
  505.     }
  506.     if {$alias != ""} {
  507.         set widget($alias) $target
  508.         set widget(rev,$target) $alias
  509.     }
  510. }
  511.  
  512. proc vTcl:update_label {t} {
  513.     global vTcl
  514.     if {$t == ""} {return}
  515.     switch [vTcl:get_class $t] {
  516.         Toplevel {
  517.             wm title $t $vTcl(w,opt,-text)
  518.             set vTcl(w,wm,title) $vTcl(w,opt,-text)
  519.         }
  520.         default {
  521.             if [catch {set txt [$t cget -text]}] {
  522.                 return
  523.             }
  524.             $t conf -text $vTcl(w,opt,-text)
  525.             vTcl:place_handles $t
  526.         }
  527.     }
  528. }
  529.  
  530. proc vTcl:set_label {t} {
  531.     global vTcl
  532.     if {$t == ""} {return}
  533.     if [catch {set txt [$t cget -text]}] {
  534.         return
  535.     }
  536.     set label [vTcl:get_string "Setting label" $t $txt]
  537.     $t conf -text $label
  538.     vTcl:place_handles $t
  539.     set vTcl(w,opt,-text) $label
  540. }
  541.  
  542. proc vTcl:set_textvar {t} {
  543.     global vTcl
  544.     if {$t == ""} {return}
  545.     set label [vTcl:get_string "Setting label" $t [$t cget -textvar]]
  546.     $t conf -textvar $label
  547.     vTcl:place_handles $t
  548. }
  549.  
  550. proc vTcl:widget_dblclick {target} {
  551.     global vTcl
  552.     set c [vTcl:get_class $target 1]
  553.     if {[info procs vTcl:widget:$c:dblclick] != ""} {
  554.         eval vTcl:widget:$c:dblclick $target
  555.     }
  556. }
  557.  
  558. proc vTcl:pack_after {target} {
  559. if {[winfo manager $target] != "pack" || $target == "."} {return}
  560.     set l [pack slaves [winfo parent $target]]
  561.     set i [lsearch $l $target]
  562.     set n [lindex $l [expr $i + 1]]
  563.     if {$n != ""} {
  564.         pack conf $target -after $n
  565.     }
  566.     vTcl:place_handles $target
  567. }
  568.  
  569. proc vTcl:pack_before {target} {
  570. if {[winfo manager $target] != "pack" || $target == "."} {return}
  571.     set l [pack slaves [winfo parent $target]]
  572.     set i [lsearch $l $target]
  573.     set n [lindex $l [expr $i - 1]]
  574.     if {$n != ""} {
  575.         pack conf $target -before $n
  576.     }
  577.     vTcl:place_handles $target
  578. }
  579.  
  580. proc vTcl:manager_update {mgr} {
  581.     global vTcl
  582.     if {$mgr == ""} {return}
  583.     set options ""
  584.     if {$vTcl(w,manager) != "$mgr"} {return}
  585.     update idletasks
  586.     if {$mgr != "wm" } {
  587.         foreach i $vTcl(m,$mgr,list) {
  588.             set value $vTcl(w,$mgr,$i)
  589.             if { $value == "" } { set value {{}} }
  590.             append options "$i $value "
  591.         }
  592.         set vTcl(var_update) "no"
  593.         set undo [vTcl:dump_widget_quick $vTcl(w,widget)]
  594.         set do "$mgr configure $vTcl(w,widget) $options"
  595.         vTcl:push_action $do $undo
  596.         set vTcl(var_update) "yes"
  597.     } else {
  598.         set    vTcl(w,wm,geometry) \
  599.             "$vTcl(w,wm,geometry,w)x$vTcl(w,wm,geometry,h)"
  600.         append vTcl(w,wm,geometry) \
  601.             "+$vTcl(w,wm,geometry,x)+$vTcl(w,wm,geometry,y)"
  602.         set    vTcl(w,wm,minsize) \
  603.             "$vTcl(w,wm,minsize,x) $vTcl(w,wm,minsize,y)"
  604.         set    vTcl(w,wm,maxsize) \
  605.             "$vTcl(w,wm,maxsize,x) $vTcl(w,wm,maxsize,y)"
  606.         set    vTcl(w,wm,aspect) \
  607.             "$vTcl(w,wm,aspect,minnum) $vTcl(w,wm,aspect,minden)"
  608.         append vTcl(w,wm,aspect) \
  609.             "+$vTcl(w,wm,aspect,maxnum)+$vTcl(w,wm,aspect,maxden)"
  610.         set    vTcl(w,wm,resizable) \
  611.             "$vTcl(w,wm,resizable,w) $vTcl(w,wm,resizable,h)"
  612. #            set    do "$mgr geometry $vTcl(w,widget) $vTcl(w,wm,geometry); "
  613.         append do "$mgr minsize $vTcl(w,widget) $vTcl(w,wm,minsize); "
  614.         append do "$mgr maxsize $vTcl(w,widget) $vTcl(w,wm,maxsize); "
  615.         append do "$mgr focusmodel $vTcl(w,widget) $vTcl(w,wm,focusmodel);"
  616.         append do "$mgr resizable $vTcl(w,widget) $vTcl(w,wm,resizable); "
  617.         append do "$mgr title $vTcl(w,widget) \"$vTcl(w,wm,title)\"; "
  618.         switch $vTcl(w,wm,state) {
  619.             withdrawn { append do "$mgr withdraw $vTcl(w,widget); " }
  620.             iconic { append do "$mgr iconify $vTcl(w,widget); " }
  621.             normal { append do "$mgr deiconify $vTcl(w,widget); " }
  622.         }
  623.         eval $do
  624.         vTcl:wm_button_update
  625.     }
  626.     vTcl:place_handles $vTcl(w,widget)
  627.     vTcl:update_top_list
  628. }
  629.  
  630.